#include "soc_osal.h"
#include "app_init.h"
#include "cmsis_os2.h"
#include "MQTTClientPersistence.h"
#include "MQTTClient.h"
#include "errcode.h"
#include "uart.h"
#include "pinctrl.h"
#include "osal_debug.h"

#include "lwip/netifapi.h"
#include "wifi_hotspot.h"
#include "wifi_hotspot_config.h"

#include "wifi/wifi_connect.h"
#include "my_device/my_device.h"
#include "oled/oled.h"
#include "my_config.h"
#include "su03t/su03t.h"
#include "json/json.h"
#include "gh_main.h"

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#include "sle_low_latency.h"
#include <sys/time.h>
#include "common_def.h"
#include "securec.h"
#include "sle_device_discovery.h"
#include "sle_errcode.h"

#include "lwip/nettool/misc.h"
#include "lwip/ip4_addr.h"
#include "lwip/netif.h"
#include "lwip/netifapi.h"
#include "lwip/sockets.h"

#include "watchdog.h"
#include "i2c.h"
#include "gpio.h"
#include "sle_connection_manager.h"
#include "sle_ssap_client.h"
#include "sle_uart_client/sle_uart_client.h"

/**
 * @brief 任务ID定义
 * main_task_id：主任务ID，用于标识和管理主任务
 * uart_task_id：UART任务ID（当前未使用，预留用于UART处理任务）
 */
osThreadId_t main_task_id; // 主任务ID
osThreadId_t uart_task_id; // UART任务ID（预留）


/**
 * @brief SLE UART任务配置参数
 * SLE_UART_TASK_STACK_SIZE：任务栈大小（0x600字节）
 * SLE_UART_TASK_PRIO：任务优先级（28，数值越大优先级越高）
 * CONFIG_UART_INT_WAIT_MS：UART中断等待时间（5ms）
 * UART_TASK_DURATION_MS：UART任务执行周期（1000ms）
 */
#define SLE_UART_TASK_STACK_SIZE            0x600 // SLE UART任务栈大小
#define SLE_UART_TASK_PRIO                  28 // SLE UART任务优先级
#define CONFIG_UART_INT_WAIT_MS            5 // UART中断等待时间(ms)
#define UART_TASK_DURATION_MS              1000 // UART任务执行周期(ms)


enum state centrl_state = UNKNOW;

/**
 * @brief MQTT连接认证信息
 * g_username：MQTT客户端用户名
 * g_password：MQTT客户端密码（加密后的字符串）
 */
char *g_username = "my_central";
char *g_password = "b9cff7584320d8708aaf61b8d7cc634878c527febef78979ce3eb5f12cec9a2b";

/**
 * @brief 设备数据管理相关变量
 * MAX_DEVICES：最大支持的设备数量（4个）
 * send_flag：数据发送标志（true表示有数据需要发送）
 * buff_out：全局输出缓冲区（大小512字节，用于临时存储输出数据）
 * oled_id：OLED显示的设备ID（当前显示哪个设备的数据）
 */
#define MAX_DEVICES 4 // 最大设备数量
bool send_flag = false; // 数据发送标志
char buff_out[512] = {0};  // 全局输出缓冲区
int oled_id=0; // OLED当前显示的设备ID


/**
 * @brief 设备数据存储结构
 * device_data：传感器数据数组（存储多个设备的传感器信息）
 * con_data：控制状态数组（存储多个设备的控制指令状态）
 * device_exists：设备存在标志数组（标记对应索引的设备是否有效）
 * device_count：当前已连接的设备数量
 * send_device_index：待发送数据的设备索引
 * send_to_oled_id：当前OLED显示的设备ID
 */
SensorData device_data[MAX_DEVICES] = {0}; // 传感器数据数组
ControlState con_data[MAX_DEVICES] = {0}; // 控制状态数组
bool device_exists[MAX_DEVICES] = {false}; // 设备存在标志
int device_count = 0; // 当前设备数量
int send_device_index = 0; // 待发送数据的设备索引
int send_to_oled_id = 0; // OLED显示的设备ID

// uint8_t lora_recv[UART_DATA_RECV_SIZE] = {0};
// uart_buffer_config_t lora_buffer_config = {.rx_buffer = lora_recv, .rx_buffer_size = UART_DATA_RECV_SIZE};

/**
 * @brief MQTT消息缓冲区
 * g_send_buffer：MQTT发布消息缓冲区（大小512字节）
 * g_response_id：命令响应ID缓冲区（存储待响应的命令ID）
 * req：状态请求指令（"reqStatus:1,"）
 * g_response_buf：默认响应JSON（表示命令执行成功）
 * g_cmdFlag：命令标志（1表示有未处理的命令）
 */
char g_send_buffer[512] = {0}; // MQTT发布缓冲区
char g_response_id[100] = {0}; // 命令响应ID缓冲区
char req[] = "reqStatus:1,"; // 状态请求指令
char g_response_buf[] =
    "{\"result_code\": 0,\"response_name\": \"control\",\"paras\": {\"result\": \"success\"}}"; // 默认成功响应JSON
uint8_t g_cmdFlag; // 命令处理标志
MQTTClient client; // MQTT客户端实例

volatile MQTTClient_deliveryToken deliveredToken; // MQTT消息投递令牌
extern int MQTTClient_init(void); // 外部声明MQTT客户端初始化函数

/**
 * @brief 查找设备索引（不存在则添加新设备）
 * 功能：在设备数组中查找指定ID的设备索引，若不存在且未达最大数量则添加新设备
 * 
 * @param device_id 要查找的设备ID
 * @return int 成功返回设备索引；失败返回-1（设备数已满）
 */
int find_device_index(int device_id) 
{
    // 首先查找是否已存在该设备
    for (int i = 0; i < MAX_DEVICES; i++) {
        if (device_exists[i] &&(device_data[i].id == device_id )) {
            return i;
        }
    }
    
    // 如果不存在且未达到最大设备数，添加新设备
    if (device_count < MAX_DEVICES) {
        for (int i = 0; i < MAX_DEVICES; i++) {
            if (!device_exists[i]) {
                snprintf(con_data[i].id, sizeof(con_data[i].id),"%d","device_id" );
                device_data[i].id = device_id;
                device_exists[i] = true;
                device_count++;
                osal_printk("New device added: ID=%d, index=%d\r\n", device_id, i);
                return i;
            }
        }
    }
    
    return -1; // 设备数已满
}

/**
 * @brief 重置所有设备数据
 * 功能：清空设备数据数组、存在标志，重置设备数量
 */
void reset_device_data(void) {
    for (int i = 0; i < MAX_DEVICES; i++) {
        if (device_exists[i]) {
            memset(&device_data[i], 0, sizeof(SensorData));
            device_exists[i] = false;
        }
    }
    device_count = 0;
}
/**
 * @brief 解析字符串中"="后的内容
 * 功能：从输入字符串中提取"="后面的子串并保存到输出缓冲区
 * 
 * @param input 输入字符串（格式如"key=value"）
 * @param output 输出缓冲区（存储提取的"value"部分）
 */
void parse_after_equal(const char *input, char *output)
{
    const char *equalsign = strchr(input, '=');
    if (equalsign != NULL) {
        // 计算等于号后面的字符串长度
        strcpy(output, equalsign + 1);
    }
}
/**
 * @brief 控制设备管理相关定义
 * MAX_CONTROL_DEVICES：最大控制设备数量（4个）
 * control_data：控制设备状态数组
 * control_device_exists：控制设备存在标志数组
 * control_device_count：当前控制设备数量
 */
// 定义控制状态结构体数组
#define MAX_CONTROL_DEVICES 4
ControlState control_data[MAX_CONTROL_DEVICES] = {0};
bool control_device_exists[MAX_CONTROL_DEVICES] = {false}; // 标记控制设备是否存在
int control_device_count = 0;                             // 当前控制设备数量


/**
 * @brief 查找控制设备索引（不存在则添加）
 * 功能：在控制设备数组中查找指定ID的设备索引，若不存在且未达最大数量则添加
 * 
 * @param device_id 要查找的控制设备ID
 * @return int 成功返回索引；失败返回-1（设备数已满）
 */
int find_control_device_index(int device_id) {
    char device_id_str[MAX_FIELD_LEN];
    snprintf(device_id_str, MAX_FIELD_LEN, "%d", device_id);
    
    // 首先查找是否已存在该控制设备
    for (int i = 0; i < MAX_CONTROL_DEVICES; i++) {
        if (control_device_exists[i] && strcmp(control_data[i].id, device_id_str) == 0) {
            return i;
        }
    }
    
    // 如果不存在且未达到最大设备数，添加新控制设备
    if (control_device_count < MAX_CONTROL_DEVICES) {
        for (int i = 0; i < MAX_CONTROL_DEVICES; i++) {
            if (!control_device_exists[i]) {
                snprintf(control_data[i].id, MAX_FIELD_LEN, "%d", device_id);
                control_device_exists[i] = true;
                control_device_count++;
                osal_printk("New control device added: ID=%d, index=%d\r\n", device_id, i);
                return i;
            }
        }
    }
    
    return -1; // 控制设备数已满
}

/**
 * @brief 设置设备控制状态
 * 功能：更新指定ID设备的控制状态（若设备存在）
 * 
 * @param device_id 设备ID
 * @param state 新的控制状态
 * @return bool 成功返回true；失败返回false
 */
bool set_device_control_state(int device_id, const ControlState *state) {
    char device_id_str[MAX_FIELD_LEN];
    snprintf(device_id_str, MAX_FIELD_LEN, "%d", device_id);
    
    // 确保传入的状态结构体中的ID正确
    ControlState temp_state = *state;
    snprintf(temp_state.id, MAX_FIELD_LEN, "%d", device_id);
    
    int idx = find_control_device_index(device_id);
    if (idx >= 0) {
        control_data[idx] = temp_state;
        osal_printk("Control state updated for device ID=%d\n", device_id);
        return true;
    }
    osal_printk("Failed to set control state: Device ID=%d not found or device limit reached\n", device_id);
    return false;
}


/**
 * @brief 获取设备控制状态
 * 功能：获取指定ID设备的当前控制状态
 * 
 * @param device_id 设备ID
 * @param state 输出参数，用于存储控制状态
 * @return bool 成功返回true；失败返回false（设备不存在）
 */
bool get_device_control_state(int device_id, ControlState *state) {
    int idx = find_control_device_index(device_id);
    if (idx >= 0 && control_device_exists[idx]) {
        *state = control_data[idx];
        return true;
    }
    return false;
}


/* 回调函数，处理连接丢失 */
void connlost(void *context, char *cause)
{
    unused(context);
    printf("Connection lost: %s\n", cause);
}
/**
 * @brief MQTT订阅主题
 * 功能：订阅指定的MQTT主题
 * 
 * @param topic 要订阅的主题
 * @return int 0（固定返回，实际可根据MQTTClient_subscribe的返回值调整）
 */
int mqtt_subscribe(const char *topic)
{
    printf("subscribe start\r\n");
    MQTTClient_subscribe(client, topic, 1);
    return 0;
}
SensorData* get_Sen(){return &device_data[now_id];}
ControlState* get_Con(){return &con_data[now_id];}


/**
 * @brief MQTT发布消息
 * 功能：向指定主题发布MQTT消息
 * 
 * @param topic 发布的主题
 * @param msg 发布的消息内容
 * @return int 成功返回0；失败返回MQTTClient_publishMessage的错误码
 */
int mqtt_publish(const char *topic, char *msg)
{
    MQTTClient_message pubmsg = MQTTClient_message_initializer;
    MQTTClient_deliveryToken token;
    int ret = 0;
    pubmsg.payload = msg;
    pubmsg.payloadlen = (int)strlen(msg);
    pubmsg.qos = 1;
    pubmsg.retained = 0;
    printf("[payload]:  %s, [topic]: %s\r\n", msg, topic);
    ret = MQTTClient_publishMessage(client, topic, &pubmsg, &token);
    if (ret != MQTTCLIENT_SUCCESS) {
        printf("mqtt publish failed\r\n");
        return ret;
    }

    return ret;
}

/**
 * @brief MQTT消息投递完成回调函数
 * 功能：当消息成功投递后被调用，打印投递令牌
 * 
 * @param context 上下文（未使用）
 * @param dt 消息投递令牌
 */
void delivered(void *context, MQTTClient_deliveryToken dt)
{
    unused(context);
    printf("Message with token value %d delivery confirmed\n", dt);

    deliveredToken = dt;
}
/**
 * @brief 发送数据到SLE设备
 * 功能：通过SLE协议向指定设备发送数据
 * 
 * @param data 要发送的数据
 */
void send_data_to_sle(const char* data){

    // uapi_uart_write(CONFIG_LORA_UART_BUS, (const uint8_t *)output, sizeof(output) + 1, 0);
    //定义了一个处理UART读操作的回调函数to
    osal_printk("send_data_to_sle:%d\r\n",data);

    char num_str[2] = { data[0], '\0' }; //从接收到的数据中提取第一个字符作为连接ID

    ssapc_write_param_t *sle_uart_send_param = get_g_sle_uart_send_param(); //获取SLE UART发送参数
    uint16_t g_sle_uart_conn_id = atoi(num_str); //将提取的字符转换为整数作为连接ID

    osal_printk("\n sle_uart_client_read_int_handler: %d\r\n", g_sle_uart_conn_id); //打印连接ID
    osal_printk("\n data: %s\r\n", data); //打印连接ID

    sle_uart_send_param->data_len = strlen(data) - 1; //设置发送数据长度
    sle_uart_send_param->data = (uint8_t *)data + 1; //设置发送数据指针，跳过第一个字节（连接ID）

    ssapc_write_req(0, g_sle_uart_conn_id, sle_uart_send_param); //通过SLE协议发送数据


    //等待响应
    sle_uart_send_param->data_len = sizeof(req); //设置发送数据长度
    sle_uart_send_param->data = (uint8_t *)req; //设置发送数据指针，跳过第一个字节（连接ID）
    ssapc_write_req(0, g_sle_uart_conn_id, sle_uart_send_param); //通过SLE协议发送数据

}
/**
 * @brief MQTT消息到达回调函数
 * 功能：当接收到MQTT消息时被调用，解析控制指令并处理
 * 
 * @param context 上下文（未使用）
 * @param topic_name 消息主题
 * @param topic_len 主题长度（未使用）
 * @param message 消息内容
 * @return int 1（表示处理完成）
 */
int messageArrived(void *context, char *topic_name, int topic_len, MQTTClient_message *message) {
    unused(context);
    unused(topic_len);

    printf("[Message recv topic]: %s\n", topic_name);
    char *payload = (char *)message->payload;
    printf("[Message]: %s\n", payload);
    printf("[Message over]\r\n");

    ControlState state;
    memset(&state, 0, sizeof(ControlState));
    
    // 解析控制消息
    parse_control_message(&state, payload);
    
    // 保存控制状态到结构体数组
    set_device_control_state(atoi(state.id), &state);
    // 打印控制状态
    print_control_state(&state);

    char output[128] = {0};
    build_message(&state, output, 128);
    send_data_to_sle(output);

    g_cmdFlag = 1;
    parse_after_equal(topic_name, g_response_id);
    MQTTClient_freeMessage(&message); // 正确释放消息
    MQTTClient_free(topic_name);     // 释放主题名称
    return 1;
}


/**
 * @brief 设置OLED显示的设备ID及数据
 * 功能：更新OLED显示的设备ID，并发送对应设备的传感器数据和控制状态
 * 
 * @param id 要显示的设备ID
 */
void set_oled_iddata(int id){
            osal_printk("set_oled_iddata\r\n");

    unsigned char buff[64] = {0};  // 进一步扩大缓冲区
    int len = 0;
    if(device_exists[id]){
        len = sprintf((char*)buff, "data.n5.val=%d\xff\xff\xff",id);
        osal_printk("buff:%s\r\n",buff);
        if (oled_write(buff, len) != len) {
            osal_printk("Error sending id data\r\n");
        }
        len = sprintf((char*)buff, "oth.n5.val=%d\xff\xff\xff",id);
        osal_printk("buff:%s\r\n",buff);
        if (oled_write(buff, len) != len) {
            osal_printk("Error sending id data\r\n");
        }
        send_to_oled_id = id;
    }else{
        len = sprintf((char*)buff, "id=0\xff\xff\xff");
        if (oled_write(buff, len) != len) {
            osal_printk("Error sending id data\r\n");
        }
        len = sprintf((char*)buff, "data.n5.val=0\xff\xff\xff");
        if (oled_write(buff, len) != len) {
            osal_printk("Error sending id data\r\n");
        }
        send_to_oled_id = 0;
    }
    set_oled_con(&con_data[send_to_oled_id]);//切换id时，更改对应控制状态
    set_oled_data(&device_data[send_to_oled_id]);//更改对应数据


}

// 根据数据解析是否为"getid"指令
static bool is_getid_command(const char *data) {
    return (data && strncmp(data, "getid", 5) == 0);
}
// 处理"getid"指令，返回"setid:ID,"格式响应
static void handle_getid_command(uint16_t conn_id) {

    // 构建响应数据
    char response[20] = {0};
    snprintf(response, sizeof(response), "setid:%d,\0", conn_id); // 假设只有一个主设备
    
    osal_printk("Sending setid response: %s\r\n", response);
    
    // 发送响应
    ssapc_write_param_t *send_param = get_g_sle_uart_send_param();
    send_param->data_len = strlen(response);
    send_param->data = (uint8_t *)response;
    
    ssapc_write_req(0, conn_id, send_param);
}
// 辅助函数：将字符串转换为布尔值表示
const char* strToBoolString(const char* str) {
    osal_printk("str:%s\r\n",str);
    osal_printk("str[0]:%c\r\n",str[0]);

    if (str == NULL) return "false";
    // 检查是否为 "true"、"1" 或非空值（根据实际需求调整）
    if (strcmp(str, "1") == 0 || 
        str[0]=='1') {
        return "true";
    }
    return "false";
}

/**
 * @brief SLE UART通知回调函数（处理接收数据）
 * 功能：当SLE UART接收到数据时被调用，解析传感器数据和控制命令
 * 
 * @param client_id 客户端ID（未使用）
 * @param conn_id 连接ID
 * @param data 接收的数据
 * @param status 状态（未使用）
 */
void sle_uart_notification_cb(uint8_t client_id, uint16_t conn_id, ssapc_handle_value_t *data, errcode_t status) {
    unused(client_id); 
    // unused(conn_id); 
    unused(status); 

    osal_printk("\n sle uart re data : %s\r\n", data->data); 
    osal_printk("connid:%d\r\n",conn_id);

    // 添加或更新设备信息
    find_control_device_index(conn_id);

    uint8_t *buff = (uint8_t *)(data->data); 

    if (is_getid_command((const char*)buff)) {
        osal_printk("Received getid command\r\n");
        // 处理getid指令，发送setid响应
        handle_getid_command(conn_id); // 假设conn_id为0，可根据实际情况修改
        return; // 返回虚拟ID表示处理了getid指令
    }else{
        // 解析帧数据
        SensorData temp_data = {0};
        ControlState temp_con = {0};
        if(buff[0]=='b'){
            int parse_result = sscanf(
                (char *)buff, 
                "begin,%d,Hum:%[^,],Tem:%[^,],Lig:%[^,],SoilHum:%[^,],uv:%[^,],rain:%[^,],co2:%[^,]",
                &temp_data.id,
                temp_data.humidity,
                temp_data.temperature,
                temp_data.ligBuffer,
                temp_data.soilHum,
                temp_data.uv,
                temp_data.rain,
                temp_data.co2
            );
        
            // 验证解析结果
            if (parse_result != 8) {
                osal_printk("Parse failed! Expected 8 fields, got %d\n", parse_result);
            }
        
            // 确保字符串安全终止
            #define SAFE_TERMINATE(str) str[sizeof(str) - 1] = '\0'
            SAFE_TERMINATE(temp_data.humidity);
            SAFE_TERMINATE(temp_data.temperature);
            SAFE_TERMINATE(temp_data.ligBuffer);
            SAFE_TERMINATE(temp_data.soilHum);
            SAFE_TERMINATE(temp_data.uv);
            SAFE_TERMINATE(temp_data.rain);
            SAFE_TERMINATE(temp_data.co2);

            // 打印并更新设备数据
            osal_printk("Parsed data for device %d:\n", temp_data.id);
            print_sensor_data(&temp_data);

            int idx = find_device_index(temp_data.id);
            if (idx >= 0) {
                // 只更新实际有值的字段
                update_device_data(&device_data[idx], &temp_data);
                osal_printk("Device %d is true\n", temp_data.id);

                send_flag = true;
                send_device_index = idx;
                osal_printk("Device %d updated\n", temp_data.id);

                memset(g_send_buffer, 0, sizeof(g_send_buffer) / sizeof(g_send_buffer[0]));
                sprintf(g_send_buffer, MQTT_DATA_SEND, DATA_SEVER_NAME,
                        device_data[send_device_index].id, 
                        device_data[send_device_index].humidity,
                        device_data[send_device_index].temperature,
                        device_data[send_device_index].ligBuffer,
                        device_data[send_device_index].soilHum,
                        device_data[send_device_index].rain,
                        device_data[send_device_index].uv,
                        device_data[send_device_index].co2);
                if(mqtt_publish(MQTT_DATATOPIC_PUB, g_send_buffer) != MQTTCLIENT_SUCCESS){
                    // MQTTClient_destroy(&client);
                    // centrl_state=CONNECTING;//重新连接
                    osal_printk("[MQTT] send error\r\n");
                }
                if(temp_data.id==send_to_oled_id){
                    set_oled_data(&device_data[send_to_oled_id]);
                    print_sensor_data(&device_data[send_to_oled_id]);
                }
                

            } else {
                osal_printk("Device %d is false\n", temp_data.id);

                osal_printk("Device limit reached for ID %d\n", temp_data.id);
            }
        }
        else if (buff[0]=='c')//处理控制命令上报
        {
            int parse_result = sscanf(
                (char *)buff, 
                "con,%[^,],fF:%[^,],wF:%[^,],sF:%[^,],swF:%[^,],r:%[^,],g:%[^,],b:%[^,]",
                temp_con.id,
                temp_con.fanFlag,
                temp_con.waterFlag,
                temp_con.sunFlag,
                temp_con.switchFlag,
                temp_con.colorNum[0],
                temp_con.colorNum[1],
                temp_con.colorNum[2]
            );
        
            // 验证解析结果
            if (parse_result != 8) {
                osal_printk("Parse failed! Expected 8 fields, got %d\n", parse_result);
            }
        
            print_control_state(&temp_con);


            int idx = find_device_index(atoi(temp_con.id));
            if (idx >= 0) {
                // 只更新实际有值的字段
                update_con_data(&con_data[idx], &temp_con);
                osal_printk("Con %s is updata\n", temp_con.id);

                memset(g_send_buffer, 0, sizeof(g_send_buffer) / sizeof(g_send_buffer[0]));

                // sprintf(g_send_buffer, MQTT_STAT_SEND, DATA_SEVER_NAME,
                //         idx, 
                //         con_data[send_device_index].sunFlag[0]=='1'?"true":"false",
                //         con_data[send_device_index].waterFlag[0]=='1'?"true":"false",
                //         con_data[send_device_index].fanFlag[0]=='1'?"true":"false",
                //         con_data[send_device_index].switchFlag[0]=='1'?"true":"false"
                //         );
                sprintf(g_send_buffer, MQTT_STAT_SEND, 
                    DATA_SEVER_NAME,
                    idx,
                    strToBoolString(temp_con.sunFlag),
                    strToBoolString(temp_con.waterFlag),
                    strToBoolString(temp_con.fanFlag),
                    strToBoolString(temp_con.switchFlag));

                if(mqtt_publish(MQTT_DATATOPIC_PUB, g_send_buffer) != MQTTCLIENT_SUCCESS){
                    // MQTTClient_destroy(&client);
                    // centrl_state=CONNECTING;//重新连接
                    osal_printk("[MQTT] send error\r\n");
                }

                if(atoi(temp_con.id)==send_to_oled_id){
                    set_oled_con(&con_data[send_to_oled_id]);

                }

            } else {
                osal_printk("Con %s is false\n", temp_con.id);
                osal_printk("Con limit reached for ID %s\n", temp_con.id);
            }
        }
        
    }

    
}

/**
 * @brief SLE UART指示回调函数
 * 功能：处理SLE UART的指示数据（收发状态等）
 * 
 * @param client_id 客户端ID（未使用）
 * @param conn_id 连接ID（未使用）
 * @param data 指示数据
 * @param status 状态（未使用）
 */
void sle_uart_indication_cb(uint8_t client_id, uint16_t conn_id, ssapc_handle_value_t *data, errcode_t status) {
    unused(client_id); 
    unused(conn_id); 
    unused(status); 

    osal_printk("\n sle uart 收发 : %s\r\n", data->data); 
}



 /**
 * @brief MQTT连接初始化
 * 功能：创建MQTT客户端，配置连接参数，建立连接并订阅主题
 * 
 * @return errcode_t 成功返回ERRCODE_SUCC；失败返回ERRCODE_FAIL
 */
static errcode_t mqtt_connect(void)
{
    int ret;
    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
    /* 初始化MQTT客户端 */
    MQTTClient_init();
    /* 创建 MQTT 客户端 */
    ret = MQTTClient_create(&client, SERVER_IP_ADDR, CLIENT_ID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
    if (ret != MQTTCLIENT_SUCCESS) {
        printf("Failed to create MQTT client, return code %d\n", ret);
        return ERRCODE_FAIL;
    }
    conn_opts.keepAliveInterval = KEEP_ALIVE_INTERVAL;
    conn_opts.cleansession = 1;
    conn_opts.username = g_username;
    conn_opts.password = g_password;
    // 绑定回调函数
    MQTTClient_setCallbacks(client, NULL, connlost, messageArrived, delivered);

    // 尝试连接
    if ((ret = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS) {
        printf("Failed to connect, return code %d\n", ret);
        MQTTClient_destroy(&client); // 连接失败时销毁客户端
        return ERRCODE_FAIL;
    }
    printf("Connected to MQTT broker!\n");
    
    osDelay(DELAY_TIME_MS);
    // 订阅MQTT主题
    mqtt_subscribe(MQTT_CMDTOPIC_SUB);
    
    return ERRCODE_SUCC;
}

//主任务
void main_task(const char *argument)
{
    unused(argument);


    // // oled串口初始化
    // oled_gpio_init();
    // oled_init_config();
    /* 等待wifi初始化完成 */
    while (wifi_is_wifi_inited() == 0) {
        (void)osDelay(10); /* 10: 延时100ms  */
    }
    /* 创建STA */
    if (wifi_sta_enable() != ERRCODE_SUCC) {
        PRINT("STA enbale fail !\r\n");
    }

    while (1) {
        osDelay(200);
        switch (centrl_state)
        {
        case UNKNOW :
        case CONNECTING : 
            centrl_state = CONNECTING;
            my_gpio_init(SENSOR_IO);
            wifi_connect();
            osDelay(DELAY_TIME_MS);
            
            if(mqtt_connect() == ERRCODE_SUCC){
                centrl_state = READY;

                oled_init();
                su_init();
                sle_uart_client_init(sle_uart_notification_cb, sle_uart_indication_cb);
            }

            break;
        case READY :
            osal_printk("READY\r\n");
            //响应部分
            if (g_cmdFlag) {
                sprintf(g_send_buffer, MQTT_CLIENT_RESPONSE, g_response_id);
                // 设备响应命令

                if(mqtt_publish(g_send_buffer, g_response_buf) != MQTTCLIENT_SUCCESS){
                    // MQTTClient_destroy(&client);
                    // centrl_state=CONNECTING;//重新连接
                    osal_printk("[MQTT] gcmd error\r\n");

                }
                g_cmdFlag = 0;
                memset(g_response_id, 0, sizeof(g_response_id) / sizeof(g_response_id[0]));

                // // 使用新函数发送指令并等待响应
                // if (send_command_and_wait_response(req, sizeof(req), 
                //                                   lora_recv, sizeof(lora_recv),
                //                                   10) > 0) { // 设置50次尝试
                //     // 复制响应数据到全局缓冲区
                //     // strncpy(g_response_buf, lora_recv, sizeof(g_response_buf) - 1);
                //     // 发布MQTT消息
                //     mqtt_publish(g_send_buffer, g_response_buf);
                // } else {
                //     osal_printk("Error: Failed to receive valid UART response\r\n");
                //     // 可以选择发送错误响应
                //     // mqtt_publish(g_send_buffer, "ERROR: Response timeout");
                // }
                // g_cmdFlag = 0;
                // memset(g_response_id, 0, sizeof(g_response_id));
            }
           
            if(send_flag && send_device_index >= 0)
            {
                //上报数据，使用设备索引获取对应数据
                

                // // 上报控制状态（可选）
                // ControlState control_state;
                    // if (get_device_control_state(atoi(device_data[send_device_index].id), &control_state)) {
                //     // 构建控制状态上报消息
                //     char control_msg[512] = {0};
                //     sprintf(control_msg, "{\"services\": [{\"service_id\": \"Control\",\"properties\": {"
                //                          "\"id\": %s,\"fan\": %s,\"water\": %s,\"sun\": %s,\"switch\": %s,"
                //                          "\"color_r\": %s,\"color_g\": %s,\"color_b\": %s}}]}",
                //                          control_state.id, control_state.fanFlag, control_state.waterFlag,
                //                          control_state.sunFlag, control_state.switchFlag,
                //                          control_state.colorNum[0], control_state.colorNum[1], control_state.colorNum[2]);
                    
                //     mqtt_publish(MQTT_CONTROLTOPIC_PUB, control_msg);
                // }

                send_flag=false;
                send_device_index = -1; // 重置设备索引
            }

            break;
        default:
            break;
        }
        // memset(g_send_buffer, 0, sizeof(g_send_buffer) / sizeof(g_send_buffer[0]));
    }
}



static void main_entry(void)
{
    osThreadAttr_t options;
    
    // 创建主任务
    options.name = "main_task";
    options.attr_bits = 0;
    options.stack_size = 0x2000;
    options.priority = osPriorityNormal;

    main_task_id = osThreadNew((osThreadFunc_t)main_task, NULL, &options);
    if (main_task_id == NULL) {
        printf("Failed to create main task!\n");
    }
    
}

/* 只运行一次app_run */
app_run(main_entry);